package com.haipumi.biz.impl;

import java.io.IOException;
import java.sql.SQLException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

import javax.annotation.Resource;
import javax.naming.NamingException;

import org.springframework.stereotype.Service;

import com.haipumi.beans.IndexTaskData;
import com.haipumi.beans.haipumi_product;
import com.haipumi.beans.haipumi_reply;
import com.haipumi.beans.haipumi_task;
import com.haipumi.beans.haipumi_user;
import com.haipumi.biz.TaskBiz;
import com.haipumi.dao.DBHelper;
import com.haipumi.dao.TaskDao;

@Service("taskBizImpl")//用来进行事务处理
public class TaskBizImpl implements TaskBiz {
	private DBHelper db=new DBHelper();
	//private static Integer[] careNum;//关注次数
	//private static String[] careId;
	private TaskDao taskDao;
	
	@Resource(name = "taskDaoMybatisImpl")
	public void setTaskDao(TaskDao taskDao) {
		this.taskDao = taskDao;
	}

	@Override
	public List<haipumi_task> findAllTask(String uid,String status) {
		//status "0"接收的任务 "1"发布的任务 "2"关注的任务 "3"屏蔽的任务
		List<haipumi_task> list=taskDao.findAllTask(uid, status);
		if("2".equals(status)){
			//再遍历每个任务的关注字段,判断是否有当前用户的id,
			for(int i=list.size()-1;i>=0;i--){
				String tider=list.get(i).getTider();
				String[] tiders=tider.split(",");
				for(int j=0;j<tiders.length;j++){
					if(uid.equals( tiders[j] )){
						break;
					}
					if(j==tiders.length-1){
						//说明到最后一次查找,也没有找到该用户id
						list.remove(i);
					}
				}
			}
		}else if("3".equals(status)){
			//再遍历每个任务的关注字段,判断是否有当前用户的id,
			for(int i=list.size()-1;i>=0;i--){
				String shield=list.get(i).getTshield();
				String[] shields=shield.split(",");
				for(int j=0;j<shields.length;j++){
					if(uid.equals( shields[j] )){
						break;
					}
					if(j==shields.length-1){
						//说明到最后一次查找,也没有找到该用户id
						list.remove(i);
					}
				}
			}
		}
		return list;
	}

	@Override
	public List<IndexTaskData> findNewTask(String tid,String uid,String ttid,String limit,String oldTask) {
		
		System.out.println(taskDao.SelectIndexTask(new haipumi_task()).size());
		
		//ttid 为0  表示查询所有类型的任务 limit 0为不限时间段,1为1小时,24一天,168一周
		List<Object> params=new ArrayList<Object>();
		List<IndexTaskData> list=null;
		String sql="";
		if(!"".equals(tid)){//这个为发布任务后,需要刷出  插入任务后自动生成的数据
			sql=" select tshield,tider,taccid,tid,uimage,ualais,ttname,tsendtime,tweather,treward,taddr,tmore,tphoto from haipumi_task t left join haipumi_user u on t.uid=u.uid left join haipumi_tasktype tt on t.ttid=tt.ttid where tid=? order by tsendtime desc";
			params.add(tid);
		}
		if(!"".equals(uid) ){//用户登陆后,进行得筛选刷出任务
			params.clear();
			//TODO 判断时间  获取时间,做一个方法,根据传入的字符串 返回一个日期字符串
			String dateLimit="";
			if(!"0".equals(limit)){
				dateLimit=" tsendtime > '"+getDate(limit)+"'";
			}
			//当uid=0 时 默认为游客的查询 查询出所有的数据
			if(!"".equals(dateLimit)){
				dateLimit=" and "+dateLimit;
			}
			
			//TODO	避免重复查询到任务	//and tid not in(10024,10022,10007)
			if(!"".equals(oldTask)){
				oldTask=oldTask.substring(0, oldTask.length()-1);//为了减去后面的,
				dateLimit+="and tid not in ( "+oldTask+" ) ";
			}
			
			if("0".equals(ttid)){
				sql=" select uimage,ualais,tid,taccid,tshield,tider,ttname,tsendtime,tweather,treward,taddr,tmore,tphoto from haipumi_task t left join haipumi_user u on t.uid=u.uid left join haipumi_tasktype tt on t.ttid=tt.ttid where t.tstatus!=3 "+dateLimit+" order by tsendtime desc limit 0,6";
			}else{
				sql=" select uimage,ualais,tid,taccid,tshield,tider,ttname,tsendtime,tweather,treward,taddr,tmore,tphoto from haipumi_task t left join haipumi_user u on t.uid=u.uid left join haipumi_tasktype tt on t.ttid=tt.ttid where t.tstatus!=3 and t.ttid=? "+dateLimit+" order by tsendtime desc limit 0,6";
				params.add(ttid);
			}
			
			if("-1".equals(uid)){//进入详情页面
				params.clear();
				sql=" select uimage,ualais,tid,taccid,tshield,tider,ttname,tsendtime,tweather,treward,taddr,tmore,tphoto from haipumi_task t left join haipumi_user u on t.uid=u.uid left join haipumi_tasktype tt on t.ttid=tt.ttid where t.tstatus!=3 and tid=? ";
				params.add(tid);
			}
			try {
				list=db.finds(sql, params,IndexTaskData.class);
				boolean shieldFlag=true;//如果用户屏蔽了该任务,用于取消接下来判断的标记
				//因为有多条数据,所以要用循环
				for(int n=list.size()-1;n>=0;n--){
					shieldFlag=true;
					if(!"0".equals(uid) || !"-1".equals(uid)){//0为游客查询,就不去判断是否屏蔽了,减小服务器压力
						//如果用户屏蔽了该任务,跳过接下来的判断,并且从List中移除该数据
						String shieldList=list.get(n).getTshield();
						String[] shields=shieldList.split(",");
						for(int s=0;s<shields.length;s++){
							if(uid.equals(shields[s])){
								list.remove(n);//要从后面开始移除,因为从前面移除,后面的位置都会发生改变
								shieldFlag=false;
								break;
							}
						}
					}
					if(shieldFlag){//在这里计算了关注人数,和关注的状态
						//将该任务的 关注状态 和 任务关注的总人数,存到list中去
						String careList=list.get(n).getTider();
						if("".equals(careList) || careList=="null"){//如果数据库中字段为空 返回的是一个null字符串
							list.get(n).setTcarenum( "" );
							list.get(n).setIscare("关注");//默认没有关注
							continue;
						}
						String[] tiders=careList.split(",");
						list.get(n).setTcarenum(Integer.toString( tiders.length ));
						list.get(n).setIscare("关注");//默认没有关注
						if(!"".equals(uid) ){
							//如果有uid传过来,判断是不是关注了该任务
							for(int i=0;i<tiders.length;i++	){
								if(uid.equals( tiders[i] ) ){
									list.get(n).setIscare("已关注");
								}
							}
						}
					}
				}
			} catch (Exception e) {
				e.printStackTrace();
				throw new RuntimeException(e);
			}
		}else{
			try {
				//用于在发布任务时,查询插入后生成的任务信息
				list=db.finds(sql, params,IndexTaskData.class);
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
		return list;
	}
	
	@Override
	public IndexTaskData addTask(haipumi_task task,haipumi_user user) {
		IndexTaskData newTaskData=null;
		task.setUid(user.getUid());
		boolean flag=taskDao.addTask(task);
		if(flag){
			try {
//				int tid=db.insertWithKey(sql, params);
				//因为有些数据是插入后才自动生成的,所以要再次查询数据库
				List<IndexTaskData> list=findNewTask(task.getTid(),"","0","0","");//ttid 为0  表示查询所有类型的任务  limit为0  表示没有发布时间限制
				newTaskData=list.get(0);
				newTaskData.setTid( task.getTid() );
			} catch (Exception e) {
				e.printStackTrace();
				throw new RuntimeException(e);
			} 
		}else{//如果插入失败,返回一个没有内容的对象
			newTaskData=new IndexTaskData();
		}
		return newTaskData;
	}

	@Override
	public String addReply(haipumi_reply reply,haipumi_user user) {
		reply.setUid(user.getUid());
		boolean flag=taskDao.addReply(reply);
		if(flag){
			return reply.getRid();
		}
		return "-1";
	}

	@Override
	public List<haipumi_reply> findReply(String tid) {
		List<haipumi_reply> list=taskDao.findReply(tid);
		return list;
	}

	@Override
	public int acceptTask(haipumi_user user, String tid) {
		int flag=taskDao.acceptTask(user, tid);
		return flag;
	}

	@Override
	public String[] caretTask(haipumi_user user, String tid,String status) {
		String[] flag={"0","0","0"};//用于存放操作结果  [0]存储操作名称,[1]存储更新数量 [2]当前任务的关注人数
		//[0] 0表示关注, 1表示已经关注过了, 2表示取消关注 
		//先查出该任务的关注人列表
		List<haipumi_task> list=taskDao.findCareList(user.getUid(), tid);
		
		String tider=list.get(0).getTider();
		//遍历该列表  如果有该用户的信息,则退出
		String[] tiders=tider.split(",");
		//如果没有人关注过
		int careNum=0;
		if(!"".equals(tider)){//如果有人关注过
			careNum=tiders.length;
		}
		
		//如果是添加,拼接后的关注列表
		tider=tider+user.getUid()+",";
		flag[2]=Integer.toString(careNum);//关注的人数
		for(int i=0;i<tiders.length;i++){
			if( ( user.getUid()).equals(tiders[i]) ){
				if("关注".equals(status)){
					flag[1]="1";
					flag[0]="1";//该用户已经关注过了,无法再关注
					return flag;
				}else if( "已关注".equals(status) ){
					flag[0]="2";//表示用户是取消关注的操作
					flag[2]=Integer.toString(careNum-1);//关注的人数
					tider="";
					//再次拼接关注列表字符串
					for(int j=0;j<tiders.length;j++){
						if(j!=i){
							tider=tider+tiders[j]+",";
						}
					}
				}
			}
		}
		//更新用户的关注列表
		String ulike=list.get(0).getUlike();
		String[] ulikes=null;
		boolean addcare=true;//添加关注的标记
		if(!"".equals(ulike)){
			ulikes=ulike.split(",");
			for(int i=0;i<ulikes.length;i++){
				if(ulikes[i].equals(tid)){//如果已经关注过了,删除关注
					addcare=false;
					ulike="";//重新拼接ulike
					for(int j=0;j<ulikes.length;j++){
						if(j!=i){
							ulike=ulike+ulikes[j]+",";
						}
					}
					break;
				}
			}
		}else{
			ulike="";
		}
		if(addcare){//说明是添加关注
			ulike=ulike+tid+",";
		}
		
		
		//更新关注列表
		boolean updateFlag=taskDao.updateCareList(tider, tid);
		boolean updateFlag2=taskDao.updateUserLike(ulike, user.getUid());
		
		int mark=-1;
		if(updateFlag && updateFlag2){
			mark=1;
		}
		
		if(mark>0 && "关注".equals(status) ){//表示是添加关注 关注的人数+1
			flag[2]=Integer.toString(careNum+1);
		}
		flag[1]=Integer.toString( mark );//存放更新的数量  现在默认更新一条数据
		return flag;
	}

	@Override
	public int shieldTask(haipumi_user user, String tid, String status) {
		//先查出该任务的屏蔽列表
		List<haipumi_task> list=taskDao.findShieldList(tid);

		//如果该任务是用户自己发布的,则不能屏蔽自己,退出接下来的判断
		if( (user.getUid() ).equals(list.get(0).getUid() ) ){
			return -2;
		}
		
		String shield=list.get(0).getTshield();
		//遍历该列表  如果有该用户的信息,则退出
		String[] shields=shield.split(",");
		
		//如果没有,则添加,拼接后的屏蔽列表
		shield=shield+user.getUid()+",";
		for(int i=0;i<shields.length;i++){
			String uid=user.getUid();
			if( ( user.getUid()).equals(shields[i]) ){
				if( "取消屏蔽".equals(status) ){
					shield="";
					//再次拼接屏蔽列表字符串
					for(int j=0;j<shields.length;j++){
						if(j!=i){
							shield=shield+shields[j]+",";
						}
					}
				}else{
					//说明已经屏蔽过了
					return -1;
				}
			}
		}
		
		//更新屏蔽列表
		return taskDao.updateTaskShield(tid, shield);
	}

	@Override
	public int operateTask(String tid, String status,haipumi_user user) {
		//status  "0"放弃 接收的任务 "
		//status  "1"完成验证 发布的任务    tstatus 未完成1  完成2  审核中3 冻结4  过期5
		
		String tider="";//关注列表
		String tshield="";//屏蔽列表
		if("2".equals(status)){
			//"2"  取消任务的关注			
			caretTask(user, tid,"已关注");
			
		}else if("3".equals(status)){
			// "3"删除 屏蔽的任务
			shieldTask( user, tid, "取消屏蔽");
		}
		
		return taskDao.operateTask(status, tid, tider, tshield);
	}

	@Override
	public Map<String,String> findRank() {
		int TrewardTotal=5;//需要查询 排行榜中积分榜的前多少名
		int careTotal=5;//需要查询 排行榜中关注榜的前多少名
		Map<String,String> Rank=new LinkedHashMap<String,String>();//排行榜  
		/*
		 * 积分1-任务id
		 * 积分2-任务id

		 * 关注1-任务id
		 * 关注2-任务id
		 */
		
		//查询积分排行榜
		String sql="select tid,treward from haipumi_task order by Treward desc limit 0, ?";
		List<Map<String, String>> list=null;
		List<Object> params=new ArrayList<Object>();
		params.add(TrewardTotal);
		try {
			list=db.findAll(sql, params);
		} catch (SQLException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} catch (NamingException e) {
			e.printStackTrace();
		}
		for(int i=0;i<TrewardTotal;i++){
			Rank.put( "积分:ID:"+list.get(i).get("tid"), list.get(i).get("treward"));
		}
		
		//查询关注排行榜
		sql="select tid,tider from haipumi_task where tider!='' ";
		list=null;
		try {
			list=db.findAll(sql, null);
		} catch (SQLException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} catch (NamingException e) {
			e.printStackTrace();
		}
		Integer[] careNum=new Integer[list.size()];//关注次数
		String[] careId =new String[list.size()];//对应的任务Id
		for(int i=0;i<list.size();i++){
			careNum[i]=list.get(i).get("tider").split(",").length;
			careId[i]=list.get(i).get("tid");
		}
		//冒泡排序	TODO 需要改进算法
		for(int i=0;i<careNum.length;i++){
			for(int j=0;j<careNum.length-i-1;j++){
				if(careNum[j]<careNum[j+1]){
					int temp=careNum[j];
					String temp2=careId[j];//将id的位置也进行替换
					
					careNum[j]=careNum[j+1];
					careNum[j+1]=temp;
					
					careId[j]=careId[j+1];
					careId[j+1]=temp2;
				}
			}
		}
        for(int i=0;i<careTotal;i++){
 			Rank.put( "关注榜:ID:"+careId[i] , Integer.toString( careNum[i] ) );
 		}
         return Rank;
	}
	
	//返回一个时间字符串
	private String getDate(String limit){
		Date d=new Date();
		SimpleDateFormat df=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		String str=df.format(d);
		if("1".equals(limit)){
			str=df.format(new Date(d.getTime() -  60 * 60 * 1000));
		}else if("24".equals(limit)){
			str=df.format(new Date(d.getTime() -  24 * 60 * 60 * 1000));
		}else if("168".equals(limit)){
			str=df.format(new Date(d.getTime() - 7 * 24 * 60 * 60 * 1000));
		}
		return str;
	}

	@Override
	public int findTaskCount() {
		//  TODO
		String sql="select count(tid) from haipumi_task where tstatus=1";
		double mark=0;
		try {
			mark=db.findDouble(sql, null);
		} catch (SQLException e) {
			e.printStackTrace();
		}
		return (int)mark;
	}

}
